<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:db="http://docbook.org/ns/docbook">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <meta http-equiv="Content-Style-Type" content="text/css" />
    <title> Práce na projektu UtopiaXML </title>
  </head>
  <body>
        <h1> Práce na projektu UtopiaXML </h1>
        <h2>Jiří Mauritz </h2>
    
        <h3> Princip fungování třídy SchemaParser</h3>
        <p>
            Instance třídy se vytváří pouze jednou, a to před samotným generováním tříd a parseru.
            Třída využívá navrženého API, které je společné s třídou pro generování parseru (více Michael Šimáček).
        </p>
        
            <h3>Uchovávání struktury</h3>
            Podle struktury XML Schematu vytvářím třídy tak, aby bylo při parsování XML souboru možné
            uložit všechny informace přehledně a logicky.
            Například pokud z informací XML Schematu zjistím, že se v parsovaném XML souboru může vyskytnout
            element A, vytvořím instanci třídy Element, který bude mít atribut se jménem A. Ne všechny
            elementy ale potřebují mít vlastní třídu. Proto řeším typy elementů, které se
            dělí na dva: simpleType a complexType. Až na kořenový element, který musí generovat třídu vždy,
            platí: pro element s complexType existuje třída, element se simpleType se pouze předá
            rodičovskému elementu.
        
        
            <h3>Typy</h3>
            <p>
                Pro rozpoznávání typů jsem napsal metodu recognizeType(), která prohledává
                elementy, které mohou mít typ (element, attribute) a vrací jej.
                Nejprve metoda kontroluje atribut 'type', který může obsahovat Schema typ,
                nebo referenci. Pokud není přítomen, zpracuje se dceřiný element simpleType.
            </p>
            <p>
                Schema typy se musí převést na Java typy - o to se stará třída TypeConverter (více Roman Lacko).
                Složitější typy se vyjadřují pomocí elementu 'restriction'. V tomto případě se
                kontoroluje v podstatě jen atribut base, ve kterém je základní typ.
                Výjimku tvoří enumeration, které představuje výčtový typ a v našem
                projektu se projeví vytvořením <span style="font-family:monospace">enum</span> a zaznamenáním konstant.
            </p>
            <p>
                Složitější typy (complexType) jsou v podstatě kořeny pro rozsáhlejší struktury. Proto
                všechny tvoří třídy a jsou uchovány po celou dobu parsování XML Schematu.
                V případě, že nějaký typ rozšiřuje jiný complexType pomocí 'extension', není problém 
                zkopírovat complexType a pouze k němu přidat zpracované dceřiné elementy v 'extension'.
            </p>
        
        
            <h3>Jak se řeší větší počet výskytů?</h3>
            <p>
                Implicitně se každý element v XML může vyskytovat v daném kontextu jen jednou.
                Toto nastavení mění atribut maxOccurs, který nastavuje maximální počet
                výskytů daného elementu, atributu atd. Pro účely generování tříd se musí 
                kontrolovat, zda je hodnota tohoto atributu větší než 1, a pokud ano, 
                vytvoří se pro daný element <span style="font-family:monospace">List</span> v rodičovském elementu.
            </p>
            <p>
                Větší problém je s indikátory - sequence a choice, které také mohou mít atribut
                maxOccurs a tím umožnit opakování některé sekvence elementů. Pro tyto případy
                se musí vytvořit zvláštní třída, která obsahuje sekvenci elementů a v rodičovské
                třídě je <span style="font-family:monospace">List</span> s touto třídou.
            </p>
        
    
        <h3>Parsování</h3>
        <p>
            Spouštěcí, a jediná metoda s veřejným přístupem, je generateClasses().
            Tato třída spustí parsování na DOM schématu. Metoda je rozdělena na 3
            logické části následovně.
        </p>
        
            <h3>Preprocessing</h3>
            <p>
                XML Schema má složitou strukturu, ale na oplátku umožňuje velmi podrobný
                popis XML. Jednou z výhod jsou reference, díky kterým si můžeme pojmenovat
                složitý element a následně ho použít vícekrát v jakémkoli jiném elementu.
            </p>
            <p>
                Tato skutečnost ale samozřejmně komplikuje parsování. Proto první fází
                parsování je preprocessing, který prohledá celý dokument a zaznamená
                si do předem vytvořených kolekcí jména elementů, na které se může jiný
                element později odkazovat. Zatím se nemůže zpracovávat struktura těchto 
                elementů, protože by se mohlo stát, že se odkazují na nějaký element, 
                který je ještě neznámý.
            </p>
            <p>
                Procházejí se elementy, na které může být odkazováno, jsou to tyto:
                
                    
                        
                            complexType
                        
                    
                    
                        
                            group
                        
                    
                    
                        
                            attributeGroup
                        
                    
                    
                        
                            simpleType
                        
                    
                
            </p>
        
        
            <h3>Zpracování referenčních elementů</h3>
            <p>
                V druhé fázi se opět projde celý dokument, opět se soutřeďuji
                na vnější elementy, ale kompletně je zpracuji a zaznamenám do 
                kolekcí, které mapují jména na typy.
                Na rozdíl od preprocessingu nyní záleží na pořadí procházení elementů.
                Například simpleType se zpracovává jako první, protože nemůže odkazovat 
                na žádný element. Zato každý další může odkazovat na něj.
                Pokaždé, když metoda najde referenci, přiřadí se elementu typ v
                dané mapě podle jména. Jedinou výjimkou je complexType, u kterého se
                přiřazuje elementu pouze jméno. Je to z toho důvodu, že z každého
                elementu complexType je dřív nebo později vytvořena třída s jedinečným
                názvem.
            </p>
        
        
            <h3>Zpracování všech elementů</h3>
            <p>
                Nyní jsem připraven zpracovat všechny ostatní elementy. K elementům
                nepřistupuji sekvenčně, ale rekurzivně, podobně jako 
                XSLT. Podobnost spočívá hlavně v tom, že pro každý element je vytvořena
                metoda (šablona), která element zpracovává nezávisle na jeho rodiči a
                sourozencích. Zpracuje se obsah elementu - tedy jeho dceřinné elementy -
                a vrací se instance třídy, která představuje daný element.
            </p>
        
    </body>
</html>
